import plugin from '../../lib/plugins/plugin.js'
import { createRequire } from 'module'
import { fileURLToPath } from 'url'
import path from 'path'
import fs from 'fs'

const require = createRequire(import.meta.url)
const __dirname = path.dirname(fileURLToPath(import.meta.url))

export class oilPrice extends plugin {
  constructor() {
    super({
      name: '今日油价',
      dsc: '查询全国今日油价信息',
      event: 'message',
      priority: 500,
      rule: [
        {
          reg: '^#今日油价$',
          fnc: 'getOilPrice'
        },
        {
          reg: '^#油价查询\\s*(.*)$',
          fnc: 'searchOilPrice'
        },
        {
          reg: '^#油价设置\\s*(.*)$',
          fnc: 'setConfig',
          permission: 'master'  
        }
      ]
    })
    
    // 初始化配置
    this.configPath = path.join(process.cwd(), 'plugins/fengyun/oilPriceConfig.json')
    this.cacheData = null
    this.cacheTime = null
    this.initConfig()
  }

 
  initConfig() {
    try {
      
      const configDir = path.dirname(this.configPath)
      if (!fs.existsSync(configDir)) {
        fs.mkdirSync(configDir, { recursive: true })
        logger.mark(`[今日油价] 创建配置目录: ${configDir}`)
      }
      
      
      if (!fs.existsSync(this.configPath)) {
       
        const defaultConfig = {
          api: {
            url: 'http://apis.juhe.cn/gnyj/query',
            key: '9d67ebe0906e7fa5c693bbb8c1b2c3ae'
          },
          plugin: {
            name: '今日油价查询',
            version: '1.0.0',
            author: '风云插件'
          },
          message: {
            forward: {
              title: '全国油价信息',
              preview: '今日油价查询结果',
              source: '油价数据'
            },
            errors: {
              network: '网络连接失败，请稍后重试',
              api: 'API服务暂时不可用',
              data: '数据解析错误'
            }
          },
          cache: {
            duration: 3600000, 
            enabled: true
          }
        }
        
        fs.writeFileSync(this.configPath, JSON.stringify(defaultConfig, null, 2))
        logger.mark(`[风云] 配置: ${this.configPath}`)
      }
      
      
      this.loadConfig()
      
    } catch (error) {
      logger.error(`[风云] 配置失败: ${error}`)
    }
  }

  
  loadConfig() {
    try {
      const configData = fs.readFileSync(this.configPath, 'utf8')
      this.config = JSON.parse(configData)
      logger.mark(`[风云] 成功`)
    } catch (error) {
      logger.error(`[风云] 失败: ${error}`)
      
      this.config = {
        api: {
          url: 'http://apis.juhe.cn/gnyj/query',
          key: '9d67ebe0906e7fa5c693bbb8c1b2c3ae'
        },
        message: {
          forward: {
            title: '全国油价信息',
            preview: '今日油价查询结果'
          }
        },
        cache: {
          duration: 3600000,
          enabled: true
        }
      }
    }
  }

  
  saveConfig() {
    try {
      fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2))
      return true
    } catch (error) {
      logger.error(`[风云] 保存配置失败: ${error}`)
      return false
    }
  }

  
  async setConfig(e) {
    const args = e.msg.replace('#油价设置', '').trim().split(' ')
    const command = args[0]
    
    try {
      switch (command) {
        case 'apikey':
          if (args.length < 2) {
            await e.reply('请输入API Key，格式: #油价设置 apikey 你的key')
            return true
          }
          this.config.api.key = args[1]
          await this.saveConfig()
          // 清除缓存
          this.cacheData = null
          this.cacheTime = null
          await e.reply('API Key 更新成功，缓存已清除')
          break
          
        case '缓存时间':
          if (args.length < 2) {
            await e.reply('请输入缓存时间(毫秒)，格式: #油价设置 缓存时间 3600000')
            return true
          }
          this.config.cache.duration = parseInt(args[1])
          await this.saveConfig()
          await e.reply(`缓存时间已设置为 ${args[1]} 毫秒`)
          break
          
        case '帮助':
          await e.reply([
            '⚙️ 油价插件配置命令（仅主人可用）:',
            '• #油价设置 apikey [key] - 设置API密钥',
            '• #油价设置 缓存时间 [毫秒] - 设置缓存时间',
            '• #油价设置 帮助 - 显示此帮助'
          ].join('\n'))
          break
          
        default:
          await e.reply('未知配置命令，使用 #油价设置 帮助 查看可用命令')
      }
    } catch (error) {
      await e.reply('配置设置失败: ' + error.message)
    }
    
    return true
  }

  async getOilPrice(e) {
    try {
      
      await e.reply('正在查询全国油价信息，请稍候...')
      
      
      const oilData = await this.fetchOilPrice()
      if (!oilData || oilData.length === 0) {
        await e.reply('油价数据获取失败，请稍后重试')
        return true
      }

     
      const forwardMsg = await this.buildForwardMessage(oilData, e)
      
      
      const sendResult = await e.reply(forwardMsg)
      
      if (!sendResult) {
        
        await this.sendNormalMessage(oilData, e)
      }
      
      return true
    } catch (error) {
      logger.error(`[风云] 查询错误: ${error}`)
      await e.reply('查询油价时出现错误，请稍后重试')
      return true
    }
  }

  async searchOilPrice(e) {
    const city = e.msg.replace('#油价查询', '').trim()
    if (!city) {
      await e.reply('请输入要查询的城市名称，例如：#油价查询 北京')
      return true
    }

    try {
      await e.reply(`正在查询${city}的油价信息...`)
      
      const oilData = await this.fetchOilPrice()
      if (!oilData || oilData.length === 0) {
        await e.reply('油价数据获取失败，请稍后重试')
        return true
      }

      const cityData = oilData.find(item => 
        item.city && item.city.includes(city)
      )

      if (!cityData) {
        await e.reply(`未找到${city}的油价信息，请检查城市名称是否正确`)
        return true
      }

      const message = this.formatCityOilPrice(cityData)
      await e.reply(message)
      
    } catch (error) {
      logger.error(`[风云] 城市查询错误: ${error}`)
      await e.reply('查询城市油价时出现错误')
    }
    
    return true
  }

  async fetchOilPrice() {
    try {
      // 检查缓存
      if (this.config.cache?.enabled && this.cacheData && this.cacheTime) {
        const now = Date.now()
        if (now - this.cacheTime < this.config.cache.duration) {
          logger.mark('[风云] 使用缓存数据')
          return this.cacheData
        }
      }

      const response = await fetch(this.config.api.url, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
        },
        body: `key=${this.config.api.key}`
      })

      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`)
      }

      const data = await response.json()
      
      if (data.error_code !== 0) {
        logger.error(`[风云] API返回错误: ${data.reason}`)
        return null
      }

      
      const result = data.result.filter(item => item.city && item['92h'] && item['92h'].trim() !== '')
      
      
      if (this.config.cache?.enabled) {
        this.cacheData = result
        this.cacheTime = Date.now()
        logger.mark(`[风云] 数据已缓存，共${result.length}个城市`)
      }
      
      return result
    } catch (error) {
      logger.error(`[风云] 获取油价数据失败: ${error}`)
      return null
    }
  }

  async buildForwardMessage(oilData, e) {
    const messages = []
    
    
    messages.push({
      message: `⛽ 全国今日油价信息\n📅 更新时间: ${this.getCurrentTime()}\n——————————————`
    })

   
    const mainCities = oilData.slice(0, 31)
    for (const cityData of mainCities) {
      messages.push({
        message: this.formatCityOilPrice(cityData)
      })
    }

    
    messages.push({
      message: this.getStatistics(oilData)
    })

    
    messages.push({
      message: '💡 使用说明:\n• 发送 #今日油价 查看全国油价\n• 发送 #油价查询 城市名 查看具体城市油价\n——————————————\n数据来源: 风云'
    })

    
    return await this.makeForwardMsg(e, messages)
  }

  formatCityOilPrice(cityData) {
    return `🏙️ ${cityData.city}\n` +
           `⛽ 92号汽油: ${cityData['92h']} 元/升\n` +
           `⛽ 95号汽油: ${cityData['95h']} 元/升\n` +
           `⛽ 98号汽油: ${cityData['98h']} 元/升\n` +
           `🛢️  0号柴油: ${cityData['0h']} 元/升`
  }

  getStatistics(oilData) {
    const prices92 = oilData.map(item => parseFloat(item['92h'])).filter(p => p)
    const prices95 = oilData.map(item => parseFloat(item['95h'])).filter(p => p)
    
    const max92 = Math.max(...prices92).toFixed(2)
    const min92 = Math.min(...prices92).toFixed(2)
    const max95 = Math.max(...prices95).toFixed(2)
    const min95 = Math.min(...prices95).toFixed(2)
    
    const max92City = oilData.find(item => item['92h'] === max92)?.city
    const min92City = oilData.find(item => item['92h'] === min92)?.city
    
    return `📊 油价统计:\n` +
           `💰 92号最高: ${max92}元 (${max92City})\n` +
           `💰 92号最低: ${min92}元 (${min92City})\n` +
           `💰 95号最高: ${max95}元\n` +
           `💰 95号最低: ${min95}元`
  }

  getCurrentTime() {
    const now = new Date()
    return now.toLocaleString('zh-CN', {
      year: 'numeric',
      month: '2-digit',
      day: '2-digit',
      hour: '2-digit',
      minute: '2-digit'
    })
  }

  async makeForwardMsg(e, messages) {
    try {
      
      const forwardMsg = await this.e.group.makeForwardMsg(messages)
      return forwardMsg
    } catch (error) {
      logger.error('[风云] 构建合并转发消息失败:', error)
     
      return messages.map(msg => msg.message).join('\n\n')
    }
  }

  async sendNormalMessage(oilData, e) {
    
    const message = 
      `⛽ 全国今日油价信息\n` +
      `📅 更新时间: ${this.getCurrentTime()}\n` +
      `——————————————\n` +
      `主要城市油价:\n` +
      oilData.slice(0, 5).map(city => 
        `${city.city}: 92#${city['92h']} 95#${city['95h']} 98#${city['98h']} 0#${city['0h']}`
      ).join('\n') +
      `\n——————————————\n` +
      `💡 发送 #油价查询 城市名 查看具体城市详细油价`
    
    await e.reply(message)
  }
}